# -.- coding: utf-8 -.-

from django import forms
from models import FichaAnima, Jugador, VentajasDependientes, DesventajasDependientes, HabilidadesSecundariasDependientes
from partidas.models import Partida
from fichas.models import FichaAnimaSinValidar
from django.forms.util import ValidationError, ErrorList
from django.contrib.auth.models import User

import re

class InicialForm(forms.ModelForm):
    class Meta:
        model = FichaAnima
        fields = ('personaje','pelo','ojos','edad','sexo'
                  #,'altura','peso'
                  )
    
    #def __init__(self, propietario):
    #    forms.ModelForm.__init__(self)
    #    self.propietario = propietario

    def __init__(self, propietario, data=None, files=None, auto_id='id_%s', prefix=None,
                 initial=None, error_class=ErrorList, label_suffix=':',
                 empty_permitted=False, instance=None):
        forms.ModelForm.__init__(self,data,files,auto_id,prefix,initial,
                                 error_class,label_suffix,empty_permitted,instance)
        jugador = User.objects.get(username=propietario)
        self.propietario = Jugador.objects.get(jugador=jugador)


    def clean_personaje(self):
        """
            Validamos que el nombre del personaje no exista para ese Jugador
            Otro jugador puede emplear el mismo nombre de personaje si quiere
        """
        pj = self.cleaned_data['personaje']
        if re.match (r'.*[^0-9a-zA-Z_].*', pj):
            raise forms.ValidationError (u'El nombre del personaje contiene caracteres no válidos')
        # Nos aseguramos que el personaje no esté ya registrado para ese jugador
        #NOTA: NO PODEMOS COMPROBAR A NIVEL DE CAMPO SI EL PERSONAJE YA EXISTE, PUESTO QUE PUEDE QUE
        #SE ESTE MODIFICANDO SOBRE INFO PREVIA, NO CREANDO UNA FICHA NUEVA: SOLUCION EL SAVE LO HACE TODO
        #try:
        #    FichaAnima.objects.get (personaje=self.cleaned_data['personaje'], propietario=self.propietario)
        #    raise forms.ValidationError (u'Ya tienes un personaje con este nombre')
        #except FichaAnima.DoesNotExist: # El personaje no existe para este usuario, todo bien
        return self.cleaned_data['personaje']

    def save(self):
        # NOTA: Si conseguimos garantizar la consistencia de los datos una vez llegados a este punto, nos podemos ahorrar
        # todos los formulario.is_valid(), ya que los datos son buenos. Se gana en eficiencia y en numero de lineas :)
        
        
        # Primero miramos que no exista un proceso de validacion pendiente
        try:
            f = FichaAnimaSinValidar.objects.get(personaje=self.cleaned_data['personaje'], propietario=self.propietario)
            # Actualizar los datos que tiene 'f' con los nuevos datos que trae el formulario
            f.personaje = self.cleaned_data['personaje']
            f.pelo = self.cleaned_data['pelo']
            f.ojos = self.cleaned_data['ojos']
            f.edad = self.cleaned_data['edad']
            f.sexo = self.cleaned_data['sexo']
            #f.altura = self.cleaned_data['altura']
            #f.peso = self.cleaned_data['peso']
            # (Nota: aqui es donde va toda la logica de relleno de cada campo en funcion de los anteriores EN TODOS LOS
            # FORMULARIOS DISTINTOS DE ESTE, QUE ES EL PRIMERO Y NO DEPENDE DE NADIE ANTERIOR).
            f.save()

        except FichaAnimaSinValidar.DoesNotExist:
        # En caso de que no se este en proceso de validacion, buscamos si la ficha existe
            try:
                f = FichaAnima.objects.get(personaje=self.cleaned_data['personaje'], propietario=self.propietario)
                # Actualizar los datos que tiene 'f' con los nuevos datos que trae el formulario
                f.personaje = self.cleaned_data['personaje']
                f.pelo = self.cleaned_data['pelo']
                f.ojos = self.cleaned_data['ojos']
                f.edad = self.cleaned_data['edad']
                f.sexo = self.cleaned_data['sexo']
                #f.altura = self.cleaned_data['altura']
                #f.peso = self.cleaned_data['peso']
                # (Nota: aqui es donde va toda la logica de relleno de cada campo en funcion de los anteriores EN TODOS LOS
                # FORMULARIOS DISTINTOS DE ESTE, QUE ES EL PRIMERO Y NO DEPENDE DE NADIE ANTERIOR).COPIAR DE ARRIBA EXACTAMENTE IGUAL.
                
                # Si esta asociada a una partida, necesita revision
                if f.partida is None:
                    f.save()
                else:
                    nueva = FichaAnimaSinValidar()
                    
                    # Se rellena 'nueva' los con los valores de 'f'
                    # SOLUCION: una forma sencilla de hacer esto es obtener los nombres de los atributos de la tabla y almacenarlos en un array
                    # de esta forma podemos conocer como se llaman, haya los que haya, y recorrerlos rellenando la ficha, tal que:
                    aux = FichaAnima._meta
                    atrib_ficha = [ver.name for ver in aux.fields]
                    #ahora, para cada atributo del modelo FichaAnima, sacamos el dato y lo copiamos en la instancia del modelo FichaAnimaSinValidar:
                    for atrib in atrib_ficha:
                        nueva.atrib = f.atrib
                    
                    # para cada campo que este formulario pueda modificar, sustituimos el valor en "nueva" por el que haya en el formulario
                    # en caso de que el usuario no haya tocado un campo, no pasa nada, pero si lo ha modficado, se sustituye igual, digamos que
                    # se la suda: si cambias cosas, las guarda cambiadas.
                    nueva.personaje = self.cleaned_data['personaje']
                    nueva.pelo = self.cleaned_data['pelo']
                    nueva.ojos = self.cleaned_data['ojos']
                    nueva.edad = self.cleaned_data['edad']
                    nueva.sexo = self.cleaned_data['sexo']
                    #nueva.altura = self.cleaned_data['altura']
                    #nueva.peso = self.cleaned_data['peso']
                    nueva.propietario = self.propietario
                    nueva.save()
                    
            except FichaAnima.DoesNotExist:
                # No existe ficha, se crea una
                f = FichaAnima()
                f.personaje = self.cleaned_data['personaje']
                f.pelo = self.cleaned_data['pelo']
                f.ojos = self.cleaned_data['ojos']
                f.edad = self.cleaned_data['edad']
                f.sexo = self.cleaned_data['sexo']
                #f.altura = self.cleaned_data['altura']
                #f.peso = self.cleaned_data['peso']
                f.propietario = self.propietario
                f.save()
        return self.cleaned_data['personaje']


class DescripcionForm(forms.ModelForm):
    class Meta:
        model = FichaAnima
        fields = ('pelo','ojos','edad','sexo'
                  #,'altura','peso'
                  )
    
    #def __init__(self, propietario):
    #    forms.ModelForm.__init__(self)
    #    self.propietario = propietario

    def __init__(self, propietario, personaje, data=None, files=None, auto_id='id_%s', prefix=None,
                 initial=None, error_class=ErrorList, label_suffix=':',
                 empty_permitted=False, instance=None):
        forms.ModelForm.__init__(self,data,files,auto_id,prefix,initial,
                                 error_class,label_suffix,empty_permitted,instance)
        jugador = User.objects.get(username=propietario)
        self.propietario = Jugador.objects.get(jugador=jugador)
        self.personaje = personaje

    def save(self):
        # NOTA: Si conseguimos garantizar la consistencia de los datos una vez llegados a este punto, nos podemos ahorrar
        # todos los formulario.is_valid(), ya que los datos son buenos. Se gana en eficiencia y en numero de lineas :)
        
        
        # Primero miramos que no exista un proceso de validacion pendiente
        try:
            f = FichaAnimaSinValidar.objects.get(personaje=self.personaje, propietario=self.propietario)
            # Actualizar los datos que tiene 'f' con los nuevos datos que trae el formulario
            f.pelo = self.cleaned_data['pelo']
            f.ojos = self.cleaned_data['ojos']
            f.edad = self.cleaned_data['edad']
            f.sexo = self.cleaned_data['sexo']
            #f.altura = self.cleaned_data['altura']
            #f.peso = self.cleaned_data['peso']
            # (Nota: aqui es donde va toda la logica de relleno de cada campo en funcion de los anteriores)
            f.save()

        except FichaAnimaSinValidar.DoesNotExist:
        # En caso de que no se este en proceso de validacion, buscamos si la ficha existe
            try:
                f = FichaAnima.objects.get(personaje=self.personaje, propietario=self.propietario)
                # Actualizar los datos que tiene 'f' con los nuevos datos que trae el formulario
                f.pelo = self.cleaned_data['pelo']
                f.ojos = self.cleaned_data['ojos']
                f.edad = self.cleaned_data['edad']
                f.sexo = self.cleaned_data['sexo']
                #f.altura = self.cleaned_data['altura']
                #f.peso = self.cleaned_data['peso']
                # (Nota: aqui es donde va toda la logica de relleno de cada campo en funcion de los anteriores EN TODOS LOS
                # FORMULARIOS DISTINTOS DE ESTE, QUE ES EL PRIMERO Y NO DEPENDE DE NADIE ANTERIOR).COPIAR DE ARRIBA EXACTAMENTE IGUAL.
                
                # Si esta asociada a una partida, necesita revision
                if f.partida is None:
                    f.save()
                else:
                    nueva = FichaAnimaSinValidar()
                    
                    # Se rellena 'nueva' los con los valores de 'f'
                    # SOLUCION: una forma sencilla de hacer esto es obtener los nombres de los atributos de la tabla y almacenarlos en un array
                    # de esta forma podemos conocer como se llaman, haya los que haya, y recorrerlos rellenando la ficha, tal que:
                    aux = FichaAnima._meta
                    atrib_ficha = [ver.name for ver in aux.fields]
                    #ahora, para cada atributo del modelo FichaAnima, sacamos el dato y lo copiamos en la instancia del modelo FichaAnimaSinValidar:
                    for atrib in atrib_ficha:
                        nueva.atrib = f.atrib
                    
                    # para cada campo que este formulario pueda modificar, sustituimos el valor en "nueva" por el que haya en el formulario
                    # en caso de que el usuario no haya tocado un campo, no pasa nada, pero si lo ha modficado, se sustituye igual, digamos que
                    # se la suda: si cambias cosas, las guarda cambiadas.
                    nueva.pelo = self.cleaned_data['pelo']
                    nueva.ojos = self.cleaned_data['ojos']
                    nueva.edad = self.cleaned_data['edad']
                    nueva.sexo = self.cleaned_data['sexo']
                    #nueva.altura = self.cleaned_data['altura']
                    #nueva.peso = self.cleaned_data['peso']
                    nueva.propietario = self.propietario
                    nueva.save()
                    
            except FichaAnima.DoesNotExist:
                pass


#DUDA PARA VICENTE:
# como puedo obtener el campo personaje, que no aparece en este formulario, pero
# que necesito para poder extraer la ficha sobre la que se van a hacer modificaciones???
# en el "DescripcionForm" era simple, xq 1 campo era "personaje", que directamente me daba esto
# pero aqui no esta ese campo...como lo obtengo??

# lo habia pensado hacer como hicimos con el campo propietario, pasandolo en el constructor
# del formulario...pero parecen muxos parametros ya no??
class Paso1Form(forms.ModelForm):
    class Meta:
        model = FichaAnima
        fields = ('nivel','categoria','raza','etnia','nephilim')

    def __init__(self, propietario, personaje, data=None, files=None, auto_id='id_%s', prefix=None,
                 initial=None, error_class=ErrorList, label_suffix=':',
                 empty_permitted=False, instance=None):
        forms.ModelForm.__init__(self,data,files,auto_id,prefix,initial,
                                 error_class,label_suffix,empty_permitted,instance)
        jugador = User.objects.get(username=propietario)
        self.propietario = Jugador.objects.get(jugador=jugador)
        self.personaje = personaje
        
    def save(self):
        # NOTA: Si conseguimos garantizar la consistencia de los datos una vez llegados a este punto, nos podemos ahorrar
        # todos los formulario.is_valid(), ya que los datos son buenos. Se gana en eficiencia y en numero de lineas :)
        
        
        # Primero miramos que no exista un proceso de validacion pendiente
        try:
            f = FichaAnimaSinValidar.objects.get(personaje=self.personaje, propietario=self.propietario)
            # Actualizar los datos que tiene 'f' con los nuevos datos que trae el formulario
            f.nivel = self.cleaned_data['nivel']
            f.categoria = self.cleaned_data['categoria']
            f.raza = self.cleaned_data['raza']
            f.etnia = self.cleaned_data['etnia']
            f.nephilim = self.cleaned_data['nephilim']
            # (Nota: aqui es donde va toda la logica de relleno de cada campo en funcion de los anteriores EN TODOS LOS
            # FORMULARIOS DISTINTOS DE ESTE, QUE ES EL PRIMERO Y NO DEPENDE DE NADIE ANTERIOR).
            f.save()

        except FichaAnimaSinValidar.DoesNotExist:
        # En caso de que no se este en proceso de validacion, buscamos si la ficha existe
            try:
                f = FichaAnima.objects.get(personaje=self.personaje, propietario=self.propietario)
                # Actualizar los datos que tiene 'f' con los nuevos datos que trae el formulario
                f.nivel = self.cleaned_data['nivel']
                f.categoria = self.cleaned_data['categoria']
                f.raza = self.cleaned_data['raza']
                f.etnia = self.cleaned_data['etnia']
                f.nephilim = self.cleaned_data['nephilim']
                # (Nota: aqui es donde va toda la logica de relleno de cada campo en funcion de los anteriores EN TODOS LOS
                # FORMULARIOS DISTINTOS DE ESTE, QUE ES EL PRIMERO Y NO DEPENDE DE NADIE ANTERIOR).COPIAR DE ARRIBA EXACTAMENTE IGUAL.
                
                # Si esta asociada a una partida, necesita revision
                if f.partida is None:
                    f.save()
                else:
                    nueva = FichaAnimaSinValidar()
                    
                    # Se rellena 'nueva' los con los valores de 'f'
                    # SOLUCION: una forma sencilla de hacer esto es obtener los nombres de los atributos de la tabla y almacenarlos en un array
                    # de esta forma podemos conocer como se llaman, haya los que haya, y recorrerlos rellenando la ficha, tal que:
                    aux = FichaAnima._meta
                    atrib_ficha = [ver.name for ver in aux.fields]
                    #ahora, para cada atributo del modelo FichaAnima, sacamos el dato y lo copiamos en la instancia del modelo FichaAnimaSinValidar:
                    for atrib in atrib_ficha:
                        nueva.atrib = f.atrib
                    
                    # para cada campo que este formulario pueda modificar, sustituimos el valor en "nueva" por el que haya en el formulario
                    # en caso de que el usuario no haya tocado un campo, no pasa nada, pero si lo ha modficado, se sustituye igual, digamos que
                    # se la suda: si cambias cosas, las guarda cambiadas.
                    nueva.nivel = self.cleaned_data['nivel']
                    nueva.categoria = self.cleaned_data['categoria']
                    nueva.raza = self.cleaned_data['raza']
                    nueva.etnia = self.cleaned_data['etnia']
                    nueva.nephilim = self.cleaned_data['nephilim']
                    nueva.propietario = self.propietario
                    nueva.save()
                    
            #ESTE CASO NO DEBE PODER DARSE (BORRAR): SE SUPONE QUE ESTE PASO Y TODOS LOS SIGUIENTES
            #SE MONTAN SOBRE UNA FICHA PREEXISTENTE, NO TIENE SENTIDO EMPEZAR UNA FICHA POR EL PASO 1,
            #(HABIENDO COMO HAY UN PASO 0) NI POR EL 7, VAMOS...
            except FichaAnima.DoesNotExist:
                pass
            #    # No existe ficha, se crea una
            #    f = FichaAnima()
            #    f.nivel = self.cleaned_data['nivel']
            #    f.categoria = self.cleaned_data['categoria']
            #    f.raza = self.cleaned_data['raza']
            #    f.etnia = self.cleaned_data['etnia']
            #    f.nephilim = self.cleaned_data['nephilim']
            #    f.propietario = self.propietario
            #    f.save()


class Paso2Form(forms.ModelForm):
    class Meta:
        model = FichaAnima
        fields = ('agi_base','con_base','des_base','fue_base','int_base','per_base','pod_base','vol_base',
                  'agi_actual','con_actual','des_actual','fue_actual','int_actual','per_actual','pod_actual','vol_actual',
                  'agi_plus','con_plus','des_plus','fue_plus','int_plus','per_plus','pod_plus','vol_plus',
                  'apariencia','gnosis','natura')

    def __init__(self, propietario, personaje, data=None, files=None, auto_id='id_%s', prefix=None,
                 initial=None, error_class=ErrorList, label_suffix=':',
                 empty_permitted=False, instance=None):
        forms.ModelForm.__init__(self,data,files,auto_id,prefix,initial,
                                 error_class,label_suffix,empty_permitted,instance)
        jugador = User.objects.get(username=propietario)
        self.propietario = Jugador.objects.get(jugador=jugador)
        self.personaje = personaje
        
    def save(self):
        try:
            f = FichaAnimaSinValidar.objects.get(personaje=self.personaje, propietario=self.propietario)
            # Actualizar los datos que tiene 'f' con los nuevos datos que trae el formulario
            f.agi_base = self.cleaned_data['agi_base']
            f.con_base = self.cleaned_data['con_base']
            f.des_base = self.cleaned_data['des_base']
            f.fue_base = self.cleaned_data['fue_base']
            f.int_base = self.cleaned_data['int_base']
            f.per_base = self.cleaned_data['per_base']
            f.pod_base = self.cleaned_data['pod_base']
            f.vol_base = self.cleaned_data['vol_base']
            #hay que añadir el resto de campos involucrados que tambien se pueden alterar manualmente (p.ej: el "plus")
            f.agi_actual = self.cleaned_data['agi_actual']
            f.con_actual = self.cleaned_data['con_actual']
            f.des_actual = self.cleaned_data['des_actual']
            f.fue_actual = self.cleaned_data['fue_actual']
            f.int_actual = self.cleaned_data['int_actual']
            f.per_actual = self.cleaned_data['per_actual']
            f.pod_actual = self.cleaned_data['pod_actual']
            f.vol_actual = self.cleaned_data['vol_actual']
            f.agi_plus = self.cleaned_data['agi_plus']
            f.con_plus = self.cleaned_data['con_plus']
            f.des_plus = self.cleaned_data['des_plus']
            f.fue_plus = self.cleaned_data['fue_plus']
            f.int_plus = self.cleaned_data['int_plus']
            f.per_plus = self.cleaned_data['per_plus']
            f.pod_plus = self.cleaned_data['pod_plus']
            f.vol_plus = self.cleaned_data['vol_plus']
            #otros parametros
            f.apariencia = self.cleaned_data['apariencia']
            f.gnosis = self.cleaned_data['gnosis']
            f.natura = self.cleaned_data['natura']
            
            # (Nota: aqui es donde va toda la logica de relleno de cada campo en funcion de los anteriores.
            agi_aux = f.agi_actual+f.agi_plus
            if agi_aux < 10:
                f.agi_bono = 5
            elif agi_aux < 11:
                f.agi_bono = 10
            elif agi_aux < 12:
                f.agi_bono = 15
            else:
                f.agi_bono = 20
            # Tras la logica: grabamos
            f.save()

        except FichaAnimaSinValidar.DoesNotExist:
        # En caso de que no se este en proceso de validacion, buscamos si la ficha existe
            try:
                f = FichaAnima.objects.get(personaje=self.personaje, propietario=self.propietario)
                # Actualizar los datos que tiene 'f' con los nuevos datos que trae el formulario
                f.agi_base = self.cleaned_data['agi_base']
                f.con_base = self.cleaned_data['con_base']
                f.des_base = self.cleaned_data['des_base']
                f.fue_base = self.cleaned_data['fue_base']
                f.int_base = self.cleaned_data['int_base']
                f.per_base = self.cleaned_data['per_base']
                f.pod_base = self.cleaned_data['pod_base']
                f.vol_base = self.cleaned_data['vol_base']
                #hay que añadir el resto de campos involucrados que tambien se pueden alterar manualmente (p.ej: el "plus")
                f.agi_actual = self.cleaned_data['agi_actual']
                f.con_actual = self.cleaned_data['con_actual']
                f.des_actual = self.cleaned_data['des_actual']
                f.fue_actual = self.cleaned_data['fue_actual']
                f.int_actual = self.cleaned_data['int_actual']
                f.per_actual = self.cleaned_data['per_actual']
                f.pod_actual = self.cleaned_data['pod_actual']
                f.vol_actual = self.cleaned_data['vol_actual']
                f.agi_plus = self.cleaned_data['agi_plus']
                f.con_plus = self.cleaned_data['con_plus']
                f.des_plus = self.cleaned_data['des_plus']
                f.fue_plus = self.cleaned_data['fue_plus']
                f.int_plus = self.cleaned_data['int_plus']
                f.per_plus = self.cleaned_data['per_plus']
                f.pod_plus = self.cleaned_data['pod_plus']
                f.vol_plus = self.cleaned_data['vol_plus']
                #otros parametros
                f.apariencia = self.cleaned_data['apariencia']
                f.gnosis = self.cleaned_data['gnosis']
                f.natura = self.cleaned_data['natura']
                
                # Si esta asociada a una partida, necesita revision
                if f.partida is None:
                    
                    # (Nota: aqui es donde va toda la logica de relleno de cada campo en funcion de los anteriores. COPIAR DEL PRIMERO SIEMPRE)
                    agi_aux = f.agi_actual+f.agi_plus
                    if agi_aux < 10:
                        f.agi_bono = 5
                    elif agi_aux < 11:
                        f.agi_bono = 10
                    elif agi_aux < 12:
                        f.agi_bono = 15
                    else:
                        f.agi_bono = 20
                    # Tras la logica: grabamos
                    f.save()
                else:
                    nueva = FichaAnimaSinValidar()
                    
                    # Se rellena 'nueva' los con los valores de 'f'
                    # SOLUCION: una forma sencilla de hacer esto es obtener los nombres de los atributos de la tabla y almacenarlos en un array
                    # de esta forma podemos conocer como se llaman, haya los que haya, y recorrerlos rellenando la ficha, tal que:
                    aux = FichaAnima._meta
                    atrib_ficha = [ver.name for ver in aux.fields]
                    #ahora, para cada atributo del modelo FichaAnima, sacamos el dato y lo copiamos en la instancia del modelo FichaAnimaSinValidar:
                    for atrib in atrib_ficha:
                        nueva.atrib = f.atrib
                    
                    # para cada campo que este formulario pueda modificar, sustituimos el valor en "nueva" por el que haya en el formulario
                    # en caso de que el usuario no haya tocado un campo, no pasa nada, pero si lo ha modficado, se sustituye igual, digamos que
                    # se la suda: si cambias cosas, las guarda cambiadas.
                    nueva.agi_base = self.cleaned_data['agi_base']
                    nueva.con_base = self.cleaned_data['con_base']
                    nueva.des_base = self.cleaned_data['des_base']
                    nueva.fue_base = self.cleaned_data['fue_base']
                    nueva.int_base = self.cleaned_data['int_base']
                    nueva.per_base = self.cleaned_data['per_base']
                    nueva.pod_base = self.cleaned_data['pod_base']
                    nueva.vol_base = self.cleaned_data['vol_base']
                    #hay que añadir el resto de campos involucrados que tambien se pueden alterar manualmente (p.ej: el "plus")
                    nueva.agi_actual = self.cleaned_data['agi_actual']
                    nueva.con_actual = self.cleaned_data['con_actual']
                    nueva.des_actual = self.cleaned_data['des_actual']
                    nueva.fue_actual = self.cleaned_data['fue_actual']
                    nueva.int_actual = self.cleaned_data['int_actual']
                    nueva.per_actual = self.cleaned_data['per_actual']
                    nueva.pod_actual = self.cleaned_data['pod_actual']
                    nueva.vol_actual = self.cleaned_data['vol_actual']
                    nueva.agi_plus = self.cleaned_data['agi_plus']
                    nueva.con_plus = self.cleaned_data['con_plus']
                    nueva.des_plus = self.cleaned_data['des_plus']
                    nueva.fue_plus = self.cleaned_data['fue_plus']
                    nueva.int_plus = self.cleaned_data['int_plus']
                    nueva.per_plus = self.cleaned_data['per_plus']
                    nueva.pod_plus = self.cleaned_data['pod_plus']
                    nueva.vol_plus = self.cleaned_data['vol_plus']
                    #otros parametros
                    nueva.apariencia = self.cleaned_data['apariencia']
                    nueva.gnosis = self.cleaned_data['gnosis']
                    nueva.natura = self.cleaned_data['natura']
                    nueva.propietario = self.propietario
                    
                    # (Nota: aqui es donde va toda la logica de relleno de cada campo en funcion de los anteriores. COPIAR DEL PRIMERO SIEMPRE)
                    agi_aux = nueva.agi_actual+nueva.agi_plus
                    if agi_aux < 10:
                        nueva.agi_bono = 5
                    elif agi_aux < 11:
                        nueva.agi_bono = 10
                    elif agi_aux < 12:
                        nueva.agi_bono = 15
                    else:
                        nueva.agi_bono = 20
                    # Tras la logica: grabamos
                    nueva.save()
                    
            except FichaAnima.DoesNotExist:
                pass

#EN DESUSO EL FORMULARIO DEL PASO 3
class Paso3Form(forms.ModelForm):
    class Meta:
        model = FichaAnima
        fields = ('ventajas','desventajas','ventajas_prop','desventajas_prop')

    def __init__(self, propietario, personaje, data=None, files=None, auto_id='id_%s', prefix=None,
                 initial=None, error_class=ErrorList, label_suffix=':',
                 empty_permitted=False, instance=None):
        forms.ModelForm.__init__(self,data,files,auto_id,prefix,initial,
                                 error_class,label_suffix,empty_permitted,instance)
        jugador = User.objects.get(username=propietario)
        self.propietario = Jugador.objects.get(jugador=jugador)
        self.personaje = personaje
        
    def save(self):
        try:
            f = FichaAnimaSinValidar.objects.get(personaje=self.personaje, propietario=self.propietario)
            # Actualizar los datos que tiene 'f' con los nuevos datos que trae el formulario
            f.ventajas = self.cleaned_data['ventajas']
            f.desventajas = self.cleaned_data['desventajas']
            f.ventajas_prop = self.cleaned_data['ventajas_prop']
            f.desventajas_prop = self.cleaned_data['desventajas_prop']
            # (Nota: aqui es donde va toda la logica de relleno de cada campo en funcion de los anteriores EN TODOS LOS
            # FORMULARIOS DISTINTOS DE ESTE, QUE ES EL PRIMERO Y NO DEPENDE DE NADIE ANTERIOR).
            f.save()

        except FichaAnimaSinValidar.DoesNotExist:
        # En caso de que no se este en proceso de validacion, buscamos si la ficha existe
            try:
                f = FichaAnima.objects.get(personaje=self.personaje, propietario=self.propietario)
                # Actualizar los datos que tiene 'f' con los nuevos datos que trae el formulario
                f.ventajas = self.cleaned_data['ventajas']
                f.desventajas = self.cleaned_data['desventajas']
                f.ventajas_prop = self.cleaned_data['ventajas_prop']
                f.desventajas_prop = self.cleaned_data['desventajas_prop']
                
                # Si esta asociada a una partida, necesita revision
                if f.partida is None:
                    f.save()
                else:
                    nueva = FichaAnimaSinValidar()
                    
                    # Se rellena 'nueva' los con los valores de 'f'
                    # SOLUCION: una forma sencilla de hacer esto es obtener los nombres de los atributos de la tabla y almacenarlos en un array
                    # de esta forma podemos conocer como se llaman, haya los que haya, y recorrerlos rellenando la ficha, tal que:
                    aux = FichaAnima._meta
                    atrib_ficha = [ver.name for ver in aux.fields]
                    #ahora, para cada atributo del modelo FichaAnima, sacamos el dato y lo copiamos en la instancia del modelo FichaAnimaSinValidar:
                    for atrib in atrib_ficha:
                        nueva.atrib = f.atrib
                    
                    # para cada campo que este formulario pueda modificar, sustituimos el valor en "nueva" por el que haya en el formulario
                    # en caso de que el usuario no haya tocado un campo, no pasa nada, pero si lo ha modficado, se sustituye igual, digamos que
                    # se la suda: si cambias cosas, las guarda cambiadas.
                    nueva.ventajas = self.cleaned_data['ventajas']
                    nueva.desventajas = self.cleaned_data['desventajas']
                    nueva.ventajas_prop = self.cleaned_data['ventajas_prop']
                    nueva.desventajas_prop = self.cleaned_data['desventajas_prop']

                    nueva.propietario = self.propietario
                    nueva.save()
                    
            except FichaAnima.DoesNotExist:
                pass

class Paso4Form(forms.ModelForm):
    class Meta:
        model = FichaAnima
        fields = ('coste_atleticas',
                  'coste_acrobacias','acrobacias_base',
                  'coste_atletismo','atletismo_base',
                  'coste_montar','montar_base',
                  'coste_nadar','nadar_base',
                  'coste_trepar','trepar_base',
                  'coste_saltar','saltar_base',
                  'coste_vigor',
                  'coste_frialdad','frialdad_base',
                  'coste_pfuerza','pfuerza_base',
                  'coste_resdolor','resdolor_base',
                  'coste_perceptivas',
                  'coste_advertir','advertir_base',
                  'coste_buscar','buscar_base',
                  'coste_rastrear','rastrear_base',
                  'coste_intelectuales',
                  'coste_animales','animales_base',
                  'coste_ciencia','ciencia_base',
                  'coste_herbolaria','herbolaria_base',
                  'coste_historia','historia_base',
                  'coste_medicina','medicina_base',
                  'coste_memorizar','memorizar_base',
                  'coste_navegacion','navegacion_base',
                  'coste_ocultismo','ocultismo_base',
                  'coste_tasacion','tasacion_base',
                  'coste_vmagica','vmagica_base',
                  'coste_sociales',
                  'coste_estilo','estilo_base',
                  'coste_intimidar','intimidar_base',
                  'coste_liderazgo','liderazgo_base',
                  'coste_persuasion','persuasion_base',
                  'coste_subterfugio',
                  'coste_cerrajeria','cerrajeria_base',
                  'coste_disfraz','disfraz_base',
                  'coste_ocultarse','ocultarse_base',
                  'coste_robo','robo_base',
                  'coste_sigilo','sigilo_base',
                  'coste_tramperia','tramperia_base',
                  'coste_venenos','venenos_base',
                  'coste_creativas',
                  'coste_arte','arte_base',
                  'coste_baile','baile_base',
                  'coste_forja','forja_base',
                  'coste_musica','musica_base',
                  'coste_tmanos','tmanos_base',
                  #'coste_especiales',          #el parametro coste_especiales desaparece por molesto (ver modelo)
                  #'especiales'                 #el formulario ya no requiere el campo especiales, puesto q se gestiona de forma distinta
                  )

    def __init__(self, propietario, personaje, data=None, files=None, auto_id='id_%s', prefix=None,
                 initial=None, error_class=ErrorList, label_suffix=':',
                 empty_permitted=False, instance=None):
        forms.ModelForm.__init__(self,data,files,auto_id,prefix,initial,
                                 error_class,label_suffix,empty_permitted,instance)
        jugador = User.objects.get(username=propietario)
        self.propietario = Jugador.objects.get(jugador=jugador)
        self.personaje = personaje
        
    def save(self):
        try:
            f = FichaAnimaSinValidar.objects.get(personaje=self.personaje, propietario=self.propietario)
            # Actualizar los datos que tiene 'f' con los nuevos datos que trae el formulario
            f.coste_atleticas = self.cleaned_data['coste_atleticas']
            f.coste_acrobacias = self.cleaned_data['coste_acrobacias']
            f.acrobacias_base = self.cleaned_data['acrobacias_base']
            f.coste_atletismo = self.cleaned_data['coste_atletismo']
            f.atletismo_base = self.cleaned_data['atletismo_base']
            f.coste_montar = self.cleaned_data['coste_montar']
            f.montar_base = self.cleaned_data['montar_base']
            f.coste_nadar = self.cleaned_data['coste_nadar']
            f.nadar_base = self.cleaned_data['nadar_base']
            f.coste_trepar = self.cleaned_data['coste_trepar']
            f.trepar_base = self.cleaned_data['trepar_base']
            f.coste_saltar = self.cleaned_data['coste_saltar']
            f.saltar_base = self.cleaned_data['saltar_base']
            f.coste_vigor = self.cleaned_data['coste_vigor']
            f.coste_frialdad = self.cleaned_data['coste_frialdad']
            f.frialdad_base = self.cleaned_data['frialdad_base']
            f.coste_pfuerza = self.cleaned_data['coste_pfuerza']
            f.pfuerza_base = self.cleaned_data['pfuerza_base']
            f.coste_resdolor = self.cleaned_data['coste_resdolor']
            f.resdolor_base = self.cleaned_data['resdolor_base']
            f.coste_perceptivas = self.cleaned_data['coste_perceptivas']
            f.coste_advertir = self.cleaned_data['coste_advertir']
            f.advertir_base = self.cleaned_data['advertir_base']
            f.coste_buscar = self.cleaned_data['coste_buscar']
            f.buscar_base = self.cleaned_data['buscar_base']
            f.coste_rastrear = self.cleaned_data['coste_rastrear']
            f.rastrear_base = self.cleaned_data['rastrear_base']
            f.coste_intelectuales = self.cleaned_data['coste_intelectuales']
            f.coste_animales = self.cleaned_data['coste_animales']
            f.animales_base = self.cleaned_data['animales_base']
            f.coste_ciencia = self.cleaned_data['coste_ciencia']
            f.ciencia_base = self.cleaned_data['ciencia_base']
            f.coste_herbolaria = self.cleaned_data['coste_herbolaria']
            f.herbolaria_base = self.cleaned_data['herbolaria_base']
            f.coste_historia = self.cleaned_data['coste_historia']
            f.historia_base = self.cleaned_data['historia_base']
            f.coste_medicina = self.cleaned_data['coste_medicina']
            f.medicina_base = self.cleaned_data['medicina_base']
            f.coste_memorizar = self.cleaned_data['coste_memorizar']
            f.memorizar_base = self.cleaned_data['memorizar_base']
            f.coste_navegacion = self.cleaned_data['coste_navegacion']
            f.navegacion_base = self.cleaned_data['navegacion_base']
            f.coste_ocultismo = self.cleaned_data['coste_ocultismo']
            f.ocultismo_base = self.cleaned_data['ocultismo_base']
            f.coste_tasacion = self.cleaned_data['coste_tasacion']
            f.tasacion_base = self.cleaned_data['tasacion_base']
            f.coste_vmagica = self.cleaned_data['coste_vmagica']
            f.vmagica_base = self.cleaned_data['vmagica_base']
            f.coste_sociales = self.cleaned_data['coste_sociales']
            f.coste_estilo = self.cleaned_data['coste_estilo']
            f.estilo_base = self.cleaned_data['estilo_base']
            f.coste_intimidar = self.cleaned_data['coste_intimidar']
            f.intimidar_base = self.cleaned_data['intimidar_base']
            f.coste_liderazgo = self.cleaned_data['coste_liderazgo']
            f.liderazgo_base = self.cleaned_data['liderazgo_base']
            f.coste_persuasion = self.cleaned_data['coste_persuasion']
            f.persuasion_base = self.cleaned_data['persuasion_base']
            f.coste_subterfugio = self.cleaned_data['coste_subterfugio']
            f.coste_cerrajeria = self.cleaned_data['coste_cerrajeria']
            f.cerrajeria_base = self.cleaned_data['cerrajeria_base']
            f.coste_disfraz = self.cleaned_data['coste_disfraz']
            f.disfraz_base = self.cleaned_data['disfraz_base']
            f.coste_ocultarse = self.cleaned_data['coste_ocultarse']
            f.ocultarse_base = self.cleaned_data['ocultarse_base']
            f.coste_robo = self.cleaned_data['coste_robo']
            f.robo_base = self.cleaned_data['robo_base']
            f.coste_sigilo = self.cleaned_data['coste_sigilo']
            f.sigilo_base = self.cleaned_data['sigilo_base']
            f.coste_tramperia = self.cleaned_data['coste_tramperia']
            f.tramperia_base = self.cleaned_data['tramperia_base']
            f.coste_venenos = self.cleaned_data['coste_venenos']
            f.venenos_base = self.cleaned_data['venenos_base']
            f.coste_creativas = self.cleaned_data['coste_creativas']
            f.coste_arte = self.cleaned_data['coste_arte']
            f.arte_base = self.cleaned_data['arte_base']
            f.coste_baile = self.cleaned_data['coste_baile']
            f.baile_base = self.cleaned_data['baile_base']
            f.coste_forja = self.cleaned_data['coste_forja']
            f.forja_base = self.cleaned_data['forja_base']
            f.coste_musica = self.cleaned_data['coste_musica']
            f.musica_base = self.cleaned_data['musica_base']
            f.coste_tmanos = self.cleaned_data['coste_tmanos']
            f.tmanos_base = self.cleaned_data['tmanos_base']
            #f.coste_especiales = self.cleaned_data['coste_especiales']
            #f.especiales = self.cleaned_data['especiales']

            # (Nota: aqui es donde va toda la logica de relleno de cada campo en funcion de los anteriores EN TODOS LOS
            # FORMULARIOS DISTINTOS DE ESTE, QUE ES EL PRIMERO Y NO DEPENDE DE NADIE ANTERIOR).
            f.save()

        except FichaAnimaSinValidar.DoesNotExist:
        # En caso de que no se este en proceso de validacion, buscamos si la ficha existe
            try:
                f = FichaAnima.objects.get(personaje=self.personaje, propietario=self.propietario)
                # Actualizar los datos que tiene 'f' con los nuevos datos que trae el formulario
                f.coste_atleticas = self.cleaned_data['coste_atleticas']
                f.coste_acrobacias = self.cleaned_data['coste_acrobacias']
                f.acrobacias_base = self.cleaned_data['acrobacias_base']
                f.coste_atletismo = self.cleaned_data['coste_atletismo']
                f.atletismo_base = self.cleaned_data['atletismo_base']
                f.coste_montar = self.cleaned_data['coste_montar']
                f.montar_base = self.cleaned_data['montar_base']
                f.coste_nadar = self.cleaned_data['coste_nadar']
                f.nadar_base = self.cleaned_data['nadar_base']
                f.coste_trepar = self.cleaned_data['coste_trepar']
                f.trepar_base = self.cleaned_data['trepar_base']
                f.coste_saltar = self.cleaned_data['coste_saltar']
                f.saltar_base = self.cleaned_data['saltar_base']
                f.coste_vigor = self.cleaned_data['coste_vigor']
                f.coste_frialdad = self.cleaned_data['coste_frialdad']
                f.frialdad_base = self.cleaned_data['frialdad_base']
                f.coste_pfuerza = self.cleaned_data['coste_pfuerza']
                f.pfuerza_base = self.cleaned_data['pfuerza_base']
                f.coste_resdolor = self.cleaned_data['coste_resdolor']
                f.resdolor_base = self.cleaned_data['resdolor_base']
                f.coste_perceptivas = self.cleaned_data['coste_perceptivas']
                f.coste_advertir = self.cleaned_data['coste_advertir']
                f.advertir_base = self.cleaned_data['advertir_base']
                f.coste_buscar = self.cleaned_data['coste_buscar']
                f.buscar_base = self.cleaned_data['buscar_base']
                f.coste_rastrear = self.cleaned_data['coste_rastrear']
                f.rastrear_base = self.cleaned_data['rastrear_base']
                f.coste_intelectuales = self.cleaned_data['coste_intelectuales']
                f.coste_animales = self.cleaned_data['coste_animales']
                f.animales_base = self.cleaned_data['animales_base']
                f.coste_ciencia = self.cleaned_data['coste_ciencia']
                f.ciencia_base = self.cleaned_data['ciencia_base']
                f.coste_herbolaria = self.cleaned_data['coste_herbolaria']
                f.herbolaria_base = self.cleaned_data['herbolaria_base']
                f.coste_historia = self.cleaned_data['coste_historia']
                f.historia_base = self.cleaned_data['historia_base']
                f.coste_medicina = self.cleaned_data['coste_medicina']
                f.medicina_base = self.cleaned_data['medicina_base']
                f.coste_memorizar = self.cleaned_data['coste_memorizar']
                f.memorizar_base = self.cleaned_data['memorizar_base']
                f.coste_navegacion = self.cleaned_data['coste_navegacion']
                f.navegacion_base = self.cleaned_data['navegacion_base']
                f.coste_ocultismo = self.cleaned_data['coste_ocultismo']
                f.ocultismo_base = self.cleaned_data['ocultismo_base']
                f.coste_tasacion = self.cleaned_data['coste_tasacion']
                f.tasacion_base = self.cleaned_data['tasacion_base']
                f.coste_vmagica = self.cleaned_data['coste_vmagica']
                f.vmagica_base = self.cleaned_data['vmagica_base']
                f.coste_sociales = self.cleaned_data['coste_sociales']
                f.coste_estilo = self.cleaned_data['coste_estilo']
                f.estilo_base = self.cleaned_data['estilo_base']
                f.coste_intimidar = self.cleaned_data['coste_intimidar']
                f.intimidar_base = self.cleaned_data['intimidar_base']
                f.coste_liderazgo = self.cleaned_data['coste_liderazgo']
                f.liderazgo_base = self.cleaned_data['liderazgo_base']
                f.coste_persuasion = self.cleaned_data['coste_persuasion']
                f.persuasion_base = self.cleaned_data['persuasion_base']
                f.coste_subterfugio = self.cleaned_data['coste_subterfugio']
                f.coste_cerrajeria = self.cleaned_data['coste_cerrajeria']
                f.cerrajeria_base = self.cleaned_data['cerrajeria_base']
                f.coste_disfraz = self.cleaned_data['coste_disfraz']
                f.disfraz_base = self.cleaned_data['disfraz_base']
                f.coste_ocultarse = self.cleaned_data['coste_ocultarse']
                f.ocultarse_base = self.cleaned_data['ocultarse_base']
                f.coste_robo = self.cleaned_data['coste_robo']
                f.robo_base = self.cleaned_data['robo_base']
                f.coste_sigilo = self.cleaned_data['coste_sigilo']
                f.sigilo_base = self.cleaned_data['sigilo_base']
                f.coste_tramperia = self.cleaned_data['coste_tramperia']
                f.tramperia_base = self.cleaned_data['tramperia_base']
                f.coste_venenos = self.cleaned_data['coste_venenos']
                f.venenos_base = self.cleaned_data['venenos_base']
                f.coste_creativas = self.cleaned_data['coste_creativas']
                f.coste_arte = self.cleaned_data['coste_arte']
                f.arte_base = self.cleaned_data['arte_base']
                f.coste_baile = self.cleaned_data['coste_baile']
                f.baile_base = self.cleaned_data['baile_base']
                f.coste_forja = self.cleaned_data['coste_forja']
                f.forja_base = self.cleaned_data['forja_base']
                f.coste_musica = self.cleaned_data['coste_musica']
                f.musica_base = self.cleaned_data['musica_base']
                f.coste_tmanos = self.cleaned_data['coste_tmanos']
                f.tmanos_base = self.cleaned_data['tmanos_base']
                #f.coste_especiales = self.cleaned_data['coste_especiales']
                #f.especiales = self.cleaned_data['especiales']
                
                # Si esta asociada a una partida, necesita revision
                if f.partida is None:
                    f.save()
                else:
                    nueva = FichaAnimaSinValidar()
                    
                    # Se rellena 'nueva' los con los valores de 'f'
                    # SOLUCION: una forma sencilla de hacer esto es obtener los nombres de los atributos de la tabla y almacenarlos en un array
                    # de esta forma podemos conocer como se llaman, haya los que haya, y recorrerlos rellenando la ficha, tal que:
                    aux = FichaAnima._meta
                    atrib_ficha = [ver.name for ver in aux.fields]
                    #ahora, para cada atributo del modelo FichaAnima, sacamos el dato y lo copiamos en la instancia del modelo FichaAnimaSinValidar:
                    for atrib in atrib_ficha:
                        nueva.atrib = f.atrib
                    
                    # para cada campo que este formulario pueda modificar, sustituimos el valor en "nueva" por el que haya en el formulario
                    # en caso de que el usuario no haya tocado un campo, no pasa nada, pero si lo ha modficado, se sustituye igual, digamos que
                    # se la suda: si cambias cosas, las guarda cambiadas.
                    nueva.coste_atleticas = self.cleaned_data['coste_atleticas']
                    nueva.coste_acrobacias = self.cleaned_data['coste_acrobacias']
                    nueva.acrobacias_base = self.cleaned_data['acrobacias_base']
                    nueva.coste_atletismo = self.cleaned_data['coste_atletismo']
                    nueva.atletismo_base = self.cleaned_data['atletismo_base']
                    nueva.coste_montar = self.cleaned_data['coste_montar']
                    nueva.montar_base = self.cleaned_data['montar_base']
                    nueva.coste_nadar = self.cleaned_data['coste_nadar']
                    nueva.nadar_base = self.cleaned_data['nadar_base']
                    nueva.coste_trepar = self.cleaned_data['coste_trepar']
                    nueva.trepar_base = self.cleaned_data['trepar_base']
                    nueva.coste_saltar = self.cleaned_data['coste_saltar']
                    nueva.saltar_base = self.cleaned_data['saltar_base']
                    nueva.coste_vigor = self.cleaned_data['coste_vigor']
                    nueva.coste_frialdad = self.cleaned_data['coste_frialdad']
                    nueva.frialdad_base = self.cleaned_data['frialdad_base']
                    nueva.coste_pfuerza = self.cleaned_data['coste_pfuerza']
                    nueva.pfuerza_base = self.cleaned_data['pfuerza_base']
                    nueva.coste_resdolor = self.cleaned_data['coste_resdolor']
                    nueva.resdolor_base = self.cleaned_data['resdolor_base']
                    nueva.coste_perceptivas = self.cleaned_data['coste_perceptivas']
                    nueva.coste_advertir = self.cleaned_data['coste_advertir']
                    nueva.advertir_base = self.cleaned_data['advertir_base']
                    nueva.coste_buscar = self.cleaned_data['coste_buscar']
                    nueva.buscar_base = self.cleaned_data['buscar_base']
                    nueva.coste_rastrear = self.cleaned_data['coste_rastrear']
                    nueva.rastrear_base = self.cleaned_data['rastrear_base']
                    nueva.coste_intelectuales = self.cleaned_data['coste_intelectuales']
                    nueva.coste_animales = self.cleaned_data['coste_animales']
                    nueva.animales_base = self.cleaned_data['animales_base']
                    nueva.coste_ciencia = self.cleaned_data['coste_ciencia']
                    nueva.ciencia_base = self.cleaned_data['ciencia_base']
                    nueva.coste_herbolaria = self.cleaned_data['coste_herbolaria']
                    nueva.herbolaria_base = self.cleaned_data['herbolaria_base']
                    nueva.coste_historia = self.cleaned_data['coste_historia']
                    nueva.historia_base = self.cleaned_data['historia_base']
                    nueva.coste_medicina = self.cleaned_data['coste_medicina']
                    nueva.medicina_base = self.cleaned_data['medicina_base']
                    nueva.coste_memorizar = self.cleaned_data['coste_memorizar']
                    nueva.memorizar_base = self.cleaned_data['memorizar_base']
                    nueva.coste_navegacion = self.cleaned_data['coste_navegacion']
                    nueva.navegacion_base = self.cleaned_data['navegacion_base']
                    nueva.coste_ocultismo = self.cleaned_data['coste_ocultismo']
                    nueva.ocultismo_base = self.cleaned_data['ocultismo_base']
                    nueva.coste_tasacion = self.cleaned_data['coste_tasacion']
                    nueva.tasacion_base = self.cleaned_data['tasacion_base']
                    nueva.coste_vmagica = self.cleaned_data['coste_vmagica']
                    nueva.vmagica_base = self.cleaned_data['vmagica_base']
                    nueva.coste_sociales = self.cleaned_data['coste_sociales']
                    nueva.coste_estilo = self.cleaned_data['coste_estilo']
                    nueva.estilo_base = self.cleaned_data['estilo_base']
                    nueva.coste_intimidar = self.cleaned_data['coste_intimidar']
                    nueva.intimidar_base = self.cleaned_data['intimidar_base']
                    nueva.coste_liderazgo = self.cleaned_data['coste_liderazgo']
                    nueva.liderazgo_base = self.cleaned_data['liderazgo_base']
                    nueva.coste_persuasion = self.cleaned_data['coste_persuasion']
                    nueva.persuasion_base = self.cleaned_data['persuasion_base']
                    nueva.coste_subterfugio = self.cleaned_data['coste_subterfugio']
                    nueva.coste_cerrajeria = self.cleaned_data['coste_cerrajeria']
                    nueva.cerrajeria_base = self.cleaned_data['cerrajeria_base']
                    nueva.coste_disfraz = self.cleaned_data['coste_disfraz']
                    nueva.disfraz_base = self.cleaned_data['disfraz_base']
                    nueva.coste_ocultarse = self.cleaned_data['coste_ocultarse']
                    nueva.ocultarse_base = self.cleaned_data['ocultarse_base']
                    nueva.coste_robo = self.cleaned_data['coste_robo']
                    nueva.robo_base = self.cleaned_data['robo_base']
                    nueva.coste_sigilo = self.cleaned_data['coste_sigilo']
                    nueva.sigilo_base = self.cleaned_data['sigilo_base']
                    nueva.coste_tramperia = self.cleaned_data['coste_tramperia']
                    nueva.tramperia_base = self.cleaned_data['tramperia_base']
                    nueva.coste_venenos = self.cleaned_data['coste_venenos']
                    nueva.venenos_base = self.cleaned_data['venenos_base']
                    nueva.coste_creativas = self.cleaned_data['coste_creativas']
                    nueva.coste_arte = self.cleaned_data['coste_arte']
                    nueva.arte_base = self.cleaned_data['arte_base']
                    nueva.coste_baile = self.cleaned_data['coste_baile']
                    nueva.baile_base = self.cleaned_data['baile_base']
                    nueva.coste_forja = self.cleaned_data['coste_forja']
                    nueva.forja_base = self.cleaned_data['forja_base']
                    nueva.coste_musica = self.cleaned_data['coste_musica']
                    nueva.musica_base = self.cleaned_data['musica_base']
                    nueva.coste_tmanos = self.cleaned_data['coste_tmanos']
                    nueva.tmanos_base = self.cleaned_data['tmanos_base']
                    #nueva.coste_especiales = self.cleaned_data['coste_especiales']
                    #nueva.especiales = self.cleaned_data['especiales']

                    nueva.propietario = self.propietario
                    nueva.save()
                    
            except FichaAnima.DoesNotExist:
                pass

class Paso5Form(forms.ModelForm):
    class Meta:
        model = FichaAnima
        fields = ('ataque_coste',
                  'ataque_base',
                  'defensa_coste',
                  'defensa_base',
                  'esquiva_coste',
                  'esquiva_base',
                  #'armas'
                  )
        
    def __init__(self, propietario, personaje, data=None, files=None, auto_id='id_%s', prefix=None,
                 initial=None, error_class=ErrorList, label_suffix=':',
                 empty_permitted=False, instance=None):
        forms.ModelForm.__init__(self,data,files,auto_id,prefix,initial,
                                 error_class,label_suffix,empty_permitted,instance)
        jugador = User.objects.get(username=propietario)
        self.propietario = Jugador.objects.get(jugador=jugador)
        self.personaje = personaje
        
    def save(self):
        try:
            f = FichaAnimaSinValidar.objects.get(personaje=self.personaje, propietario=self.propietario)
            # Actualizar los datos que tiene 'f' con los nuevos datos que trae el formulario
            f.ataque_coste = self.cleaned_data['ataque_coste']
            f.ataque_base = self.cleaned_data['ataque_base']
            f.defensa_coste = self.cleaned_data['defensa_coste']
            f.defensa_base = self.cleaned_data['defensa_base']
            f.esquiva_coste = self.cleaned_data['esquiva_coste']
            f.esquiva_base = self.cleaned_data['esquiva_base']
            #f.armas = self.cleaned_data['armas']
            
            # (Nota: aqui es donde va toda la logica de relleno de cada campo en funcion de los anteriores EN TODOS LOS
            # FORMULARIOS DISTINTOS DE ESTE, QUE ES EL PRIMERO Y NO DEPENDE DE NADIE ANTERIOR).
            f.save()

        except FichaAnimaSinValidar.DoesNotExist:
        # En caso de que no se este en proceso de validacion, buscamos si la ficha existe
            try:
                f = FichaAnima.objects.get(personaje=self.personaje, propietario=self.propietario)
                # Actualizar los datos que tiene 'f' con los nuevos datos que trae el formulario
                f.ataque_coste = self.cleaned_data['ataque_coste']
                f.ataque_base = self.cleaned_data['ataque_base']
                f.defensa_coste = self.cleaned_data['defensa_coste']
                f.defensa_base = self.cleaned_data['defensa_base']
                f.esquiva_coste = self.cleaned_data['esquiva_coste']
                f.esquiva_base = self.cleaned_data['esquiva_base']
                #f.armas = self.cleaned_data['armas']
                
                # Si esta asociada a una partida, necesita revision
                if f.partida is None:
                    f.save()
                else:
                    nueva = FichaAnimaSinValidar()
                    
                    # Se rellena 'nueva' los con los valores de 'f'
                    # SOLUCION: una forma sencilla de hacer esto es obtener los nombres de los atributos de la tabla y almacenarlos en un array
                    # de esta forma podemos conocer como se llaman, haya los que haya, y recorrerlos rellenando la ficha, tal que:
                    aux = FichaAnima._meta
                    atrib_ficha = [ver.name for ver in aux.fields]
                    #ahora, para cada atributo del modelo FichaAnima, sacamos el dato y lo copiamos en la instancia del modelo FichaAnimaSinValidar:
                    for atrib in atrib_ficha:
                        nueva.atrib = f.atrib
                    
                    # para cada campo que este formulario pueda modificar, sustituimos el valor en "nueva" por el que haya en el formulario
                    # en caso de que el usuario no haya tocado un campo, no pasa nada, pero si lo ha modficado, se sustituye igual, digamos que
                    # se la suda: si cambias cosas, las guarda cambiadas.
                    nueva.ataque_coste = self.cleaned_data['ataque_coste']
                    nueva.ataque_base = self.cleaned_data['ataque_base']
                    nueva.defensa_coste = self.cleaned_data['defensa_coste']
                    nueva.defensa_base = self.cleaned_data['defensa_base']
                    nueva.esquiva_coste = self.cleaned_data['esquiva_coste']
                    nueva.esquiva_base = self.cleaned_data['esquiva_base']
                    #nueva.armas = self.cleaned_data['armas']

                    nueva.propietario = self.propietario
                    nueva.save()
                    
            except FichaAnima.DoesNotExist:
                pass
            
class VentajasForm(forms.ModelForm):
    class Meta:
        model = VentajasDependientes
        fields = ('nombre','descripcion','coste')
        
    def save_propietario(self, jugpropietario):
        nuevavent = VentajasDependientes()
        if jugpropietario is not None:
            nuevavent.propietario = jugpropietario
            nuevavent.nombre = self.cleaned_data['nombre']
            nuevavent.descripcion = self.cleaned_data['descripcion']
            nuevavent.coste = self.cleaned_data['coste']
            
            nuevavent.save()

class DesventajasForm(forms.ModelForm):
    class Meta:
        model = DesventajasDependientes
        fields = ('nombre','descripcion','coste')
        
    def save_propietario(self, jugpropietario):
        nuevadesv = DesventajasDependientes()
        if jugpropietario is not None:
            nuevadesv.propietario = jugpropietario
            nuevadesv.nombre = self.cleaned_data['nombre']
            nuevadesv.descripcion = self.cleaned_data['descripcion']
            nuevadesv.coste = self.cleaned_data['coste']
            
            nuevadesv.save()
            
class HabilidadSecForm(forms.ModelForm):
    class Meta:
        model = HabilidadesSecundariasDependientes
        fields = ('nombre','descripcion','coste','base','bono','espe','cate','final')
        
    def save_propietario(self, jugpropietario):
        nuevahab = HabilidadesSecundariasDependientes()
        if jugpropietario is not None:
            nuevahab.propietario = jugpropietario
            nuevahab.nombre = self.cleaned_data['nombre']
            nuevahab.descripcion = self.cleaned_data['descripcion']
            nuevahab.coste = self.cleaned_data['coste']
            nuevahab.base = self.cleaned_data['base']
            nuevahab.bono = self.cleaned_data['bono']
            nuevahab.espe = self.cleaned_data['espe']
            nuevahab.cate = self.cleaned_data['cate']
            nuevahab.final = self.cleaned_data['final']
            
            nuevahab.save()

